import * as fs from 'fs';
import * as path from 'path';
import { PromptTemplate } from '../types/prompt';

export class PromptManager {
  private prompts: PromptTemplate[] = [];
  private currentPromptIndex: number = 0;
  private promptsFilePath: string;

  constructor(promptsFilePath: string = 'prompts/default.json') {
    // 在Electron环境中安全地解析路径
    try {
      this.promptsFilePath = path.resolve(promptsFilePath);
    } catch (error) {
      console.warn('路径解析失败，使用默认路径:', error);
      this.promptsFilePath = promptsFilePath;
    }
    this.loadPrompts();
  }
  // 从JSON文件加载提示词
  private loadPrompts(): void {
    try {
      if (fs.existsSync(this.promptsFilePath)) {
        const data = fs.readFileSync(this.promptsFilePath, 'utf-8');
        const parsed = JSON.parse(data);
        this.prompts = parsed.prompts || [];
        console.log(`已加载 ${this.prompts.length} 个提示词模板`);
      } else {
        console.warn(`提示词文件不存在: ${this.promptsFilePath}`);
        // 创建默认提示词
        this.createDefaultPrompts();
      }
    } catch (error) {
      console.error('加载提示词失败:', error);
      // 创建默认提示词
      this.createDefaultPrompts();
    }
  }

  // 创建默认提示词
  private createDefaultPrompts(): void {
    this.prompts = [
      {
        title: "默认助手",
        content: "你是一个有用的AI助手，请尽力回答用户的问题。",
        description: "通用AI助手提示词"
      }
    ];
    console.log('已创建默认提示词');
  }

  // 保存提示词到JSON文件
  private savePrompts(): void {
    try {
      // 安全地获取目录路径
      let dir: string;
      try {
        dir = path.dirname(this.promptsFilePath);
      } catch (error) {
        console.warn('无法解析目录路径，跳过保存');
        return;
      }
      
      // 确保目录存在
      if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
      }
      
      const data = {
        prompts: this.prompts
      };
      fs.writeFileSync(this.promptsFilePath, JSON.stringify(data, null, 2), 'utf-8');
      console.log('提示词已保存');
    } catch (error) {
      console.error('保存提示词失败:', error);
    }
  }

  // 处理提示词中的变量替换
  private processVariables(content: string): string {
    // 预定义的安全变量
    const variables: Record<string, string> = {
      'currentDate': new Date().toLocaleDateString(),
      'currentDay': new Date().toLocaleDateString('zh-CN', { weekday: 'long' }),
      'currentTime': new Date().toLocaleTimeString(),
      'currentDateTime': new Date().toLocaleString(),
      'currentYear': new Date().getFullYear().toString(),
      'currentMonth': (new Date().getMonth() + 1).toString(),
      'currentWeekday': new Date().toLocaleDateString('zh-CN', { weekday: 'long' })
    };

    // 使用安全的变量替换，格式：{{variableName}}
    return content.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
      if (variables.hasOwnProperty(varName)) {
        return variables[varName];
      } else {
        console.warn(`未定义的变量: ${varName}`);
        return match; // 保持原始文本
      }
      });
    }

  // 添加自定义变量
  addCustomVariable(name: string, value: string): void {
    // 这里可以扩展为支持自定义变量，目前使用预定义变量
    console.log(`暂不支持自定义变量，请使用预定义变量: ${Object.keys(this.getAvailableVariables()).join(', ')}`);
  }

  // 获取可用变量列表
  getAvailableVariables(): Record<string, string> {
    return {
      'currentDate': '当前日期',
      'currentDay': '当前星期',
      'currentTime': '当前时间',
      'currentDateTime': '当前日期时间',
      'currentYear': '当前年份',
      'currentMonth': '当前月份',
      'currentWeekday': '当前星期几'
    };
  }

  // 获取当前提示词
  getCurrentPrompt(): PromptTemplate | null {
    if (this.prompts.length === 0) return null;
    const prompt = this.prompts[this.currentPromptIndex];
    return {
      ...prompt,
      content: this.processVariables(prompt.content)
    };
  }

  // 获取当前提示词内容
  getCurrentPromptContent(): string {
    const prompt = this.getCurrentPrompt();
    return prompt ? prompt.content : '';
  }

  // 切换提示词
  switchPrompt(index: number): boolean {
    if (index >= 0 && index < this.prompts.length) {
      this.currentPromptIndex = index;
      console.log(`已切换到提示词: ${this.prompts[index].title}`);
      return true;
    }
    return false;
  }

  // 根据标题切换提示词
  switchPromptByTitle(title: string): boolean {
    const index = this.prompts.findIndex(prompt => prompt.title === title);
    if (index !== -1) {
      this.currentPromptIndex = index;
      console.log(`已切换到提示词: ${title}`);
      return true;
    }
    return false;
  }

  // 获取所有提示词
  getAllPrompts(): PromptTemplate[] {
    return this.prompts.map(prompt => ({
      ...prompt,
      content: this.processVariables(prompt.content)
    }));
  }

  // 获取当前提示词索引
  getCurrentPromptIndex(): number {
    return this.currentPromptIndex;
  }

  // 添加新提示词
  addPrompt(prompt: PromptTemplate): void {
    this.prompts.push(prompt);
    this.savePrompts();
    console.log(`已添加提示词: ${prompt.title}`);
  }

  // 更新提示词
  updatePrompt(index: number, prompt: PromptTemplate): boolean {
    if (index >= 0 && index < this.prompts.length) {
      this.prompts[index] = prompt;
      this.savePrompts();
      console.log(`已更新提示词: ${prompt.title}`);
      return true;
    }
    return false;
  }

  // 删除提示词
  deletePrompt(index: number): boolean {
    if (index >= 0 && index < this.prompts.length) {
      const deleted = this.prompts.splice(index, 1)[0];
      if (this.currentPromptIndex >= this.prompts.length) {
        this.currentPromptIndex = Math.max(0, this.prompts.length - 1);
      }
      this.savePrompts();
      console.log(`已删除提示词: ${deleted.title}`);
      return true;
    }
    return false;
  }

  // 重新加载提示词文件
  reload(): void {
    this.loadPrompts();
  }

  // 列出所有提示词
  listPrompts(): string {
    let result = '\n=== 可用提示词列表 ===\n';
    
    this.prompts.forEach((prompt, index) => {
      const isCurrent = index === this.currentPromptIndex;
      const prefix = isCurrent ? '► ' : '  ';
      result += `${prefix}${index}. ${prompt.title}\n`;
    });
    
    result += '\n使用 /prompt <索引> 切换提示词\n';
    return result;
  }
}

export const promptManager = new PromptManager();
